COMMENT ⊗   VALID 00003 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	$
C00007 00003	One of the  design goals for  the current implementation of  SAIL was
C00012 ENDMK
C⊗;
$
$M1NGB37.FNT[FNT,BGB]
$J
SAIL is a high-level programming language for the PDP-10
computer. It includes an extended ALGOL compiler and a companion
set of execution-time routines.  
In addition to ALGOL, the language features:
(1) flexible linking to hand-coded machine language algorithms,
(2) complete access to the PDP-10 I/O facilities, (3) a complete
system of compile-time arithmetic and logic as well as a flexible
macro system, (4) user modifiable error handling,
(5) backtracking, and (6) interrupt facilities.
 Furthermore,
a subset of the SAIL language, called LEAP, provides facilities 
for (1) sets and lists, (2) an associative data structure, (3)
independent processes, and (4) procedure variables.
The LEAP subset of SAIL is an 
extension of the LEAP language, which was designed by J. Feldman
and P. Rovner, and implemented on Lincoln Laboratory's TX-2.  This 
language is described in some detail in an article entitled "An
Algol-Based Associative Language" (see [Feldman & Rovner]).
The extensions to LEAP are partially described in "Recent Developements
in SAIL" (see [Feldman]).  

This manual describes the SAIL language and the execution-time
routines for the typical SAIL user: a non-novice programmer with some knowledge
of ALGOL.  It lies somewhere between being a tutorial and a reference
manual. 

For the first reading, a light skim of sections 1 through 4 followed by 
a careful perusal of subsection 19.1 should be adequate to familiarize
the new user with the differences between ALGOL and SAIL and allow him
to start writing programs in SAIL.
The other sections of this manual are relatively self contained, and can
be read when one wants to know about the features they describe.  The exceptions
to this 
rule are sections 10, 11, and 12. These describe the basics of the LEAP and are
essential for understanding of the following sections. 
Much of the implementation
information contained in older versions of this manual has been moved to 
the appendices and a forthcoming implementation manual. 

An attempt has been made to keep forward references to a minimum.  In other words,
if the manual is freely using concepts unfamilar to you, they are probably defined
in an earlier section.
However, the definitions of some common concepts such as "variable" and "identifier"
have been left until section 19.
One of the  design goals for  the current implementation of  SAIL was
to retain, as  far as possible, compatibility with previous versions.
We  have  been  fairly   successful  in  retaining  source   language
compatibility,  but not  completely  successful,  since other  design
considerations  frequently proved  to be  overriding.  Most  of these
exceptions  occur  with  constructs  that,  while   never  explicitly
illegal,  were never  quite "legal"  either. Essentially,  this means
that programs which  contain "hacks" may  or may not  be able to  run
unchanged. For instance, assignment of a random  integer to the datum
of a  set item will cause horrible things to  happen when the item is
deleted.  One should consult the appropriate sections of  this manual
for detailed information. Other notable incompatibilities include:

1.  The procedure  implementation was  somewhat changed.  This change
should  not adversely affect any programs  that do not use START_CODE
or link to assembly language routines.
However, for efficiency the user  may want to
consider  declaring some  of his  smaller procedures  SIMPLE.
The new implementation required that another register  ('12)
be dedicated  to SAIL's  exclusive use.   Programs  that modify  this
register do so at their utmost peril.

2.  The effect of  DEFINEing a macro  that was already  declared in a
higher block  is to  redefine the  macro (thus  violating the  normal
block structure conventions of ALGOL).

3.  Non-own sets are  deallocated when  the block  in which  they are
declared is exited.

4. The  storage  management  system for  arrays  has  been  modified.
Again, this  change  can only  affect programs  that allocate  arrays
using START_CODE.

WARNING:  This list is primarily  intended as a general  guide to the
most outstanding incompatibilities,  and should  not be construed  as
being complete.   Users are strongly  urged to read over  the manual,
since  doing  so  will introduce  them  to the  new  features  of the
language, some of which are  quite useful, as well as  informing them
of  any  subtle  changes in  the  old  semantics.  In any  event  the
experience at Stanford  was that  conversion of    programs
proved to be surprisingly  easy, with the only real  holdouts being a
couple giants  that made heavy and subtle use of  START_CODE blocks and assembly
language routines.

One last word: There is currently no such thing as a CHECKED itemvar.
With this one exception, everything the manual says is in the language
really is.
$.